/*
 * File:   ParserMatrizExtendida.cpp
 * Author: nicolas
 * 
 * Created on 28 de septiembre de 2012, 22:57
 */

#include "ParserMatrizExtendida_1.h"

using namespace std;

ParserMatrizExtendida::ParserMatrizExtendida() {
    this->delimitadores = ",.;:()=?¡¿_{}[]#!|¬°$%&/<>";
    this->limpiarParserMatriz();
          
}

ParserMatrizExtendida::ParserMatrizExtendida(const ParserMatrizExtendida& orig) {
}

ParserMatrizExtendida::~ParserMatrizExtendida(){
}

bool ParserMatrizExtendida::isDelimitador(char letra) {
    if(this->delimitadores.find(letra) != string::npos){
      //  cout << "contiene" << endl;
        return true;
    }
    //   cout << "no contiene" << endl;
    return false;
}

bool ParserMatrizExtendida::finDePalabra(const char nuevaLetra){
    if( (nuevaLetra == ' ' and this->flags[0] ==false )or 
            isDelimitador(nuevaLetra))
        return true;
    return false;
}

void ParserMatrizExtendida::flagsReset(){
    for(int i = 0 ; i < CANT_FLAGS ; i++){
        this->flags[i] = false;
    }
        
}


std::string * ParserMatrizExtendida::ingresarNuevaLetra(char letra){
    //cout<< endl << "termino a devolver " << terminoAdevolver << endl << endl;
    
    int resultado = aplicarReglas(letra);
       
    if (resultado == PALABRA_COMPLETA){
         string * palabra = new string;             
                  
         if (!terminoTemporal.empty() ){
            if (terminoAdevolver.find_last_of(terminoTemporal) != string::npos){
                *palabra = terminoAdevolver.substr(0,terminoAdevolver.length() - terminoTemporal.length());
                terminoAdevolver.assign(terminoTemporal);
                this->flagsReset();
                /* revisar si levanta bien o no !!!!!!!!!!*/
                terminoTemporal.clear();
                
                pos = this->terminoAdevolver.length();
           }
        }
        else{
            pos = 0;
            *palabra = terminoAdevolver;
            terminoAdevolver.clear();
        }
        return palabra;
    }
    else{
        pos++;
        return NULL;
    }
};

int ParserMatrizExtendida::aplicarReglas(const char letra){
    int resultado;
    
    if (pos == 0) {
        if (letra >= 'A' and letra <= 'Z')
            flags[0] = true;
        else {
            flags[0] = false;
        }
        resultado = PALABRA_INCOMPLETA;
    }
    else if(pos != 0) {
        if (flags[0] == true and flags[1] == true and (letra < 'A' or letra > 'Z') and letra != ' ') {
            //en este caso empieza una nueva palabra, la anterior era mayus pero esta no
            this->terminoTemporal.append(new char(letra));
            resultado = PALABRA_COMPLETA;
        }
        else if (flags[0] == true and letra == ' ') {
            flags[1] = true;
            //this->terminoTemporal.append(new char(letra));
            resultado = PALABRA_INCOMPLETA;
        }
        else if (isDelimitador(letra)){
            flags[0] = false;
            flags[1] = false;
            resultado = PALABRA_COMPLETA;
        }
        else if (flags[0] == true and flags[1] == true and (letra >= 'A' and letra <= 'Z') and letra != ' ') {
            flags[1] = false;
            this->terminoTemporal.clear();
            resultado = PALABRA_INCOMPLETA;
        }
        else if (flags[0] == false and letra == ' ') {
            resultado = PALABRA_COMPLETA;
        }
        else resultado = PALABRA_INCOMPLETA;  // aca iria si es una letra "normal" analizar otros casos, cuales????
    }
      
    if(!this->eliminarSignos(letra)){
         char * ltr = new char(tolower(letra));
      //   cout << " ->> agrego a: " <<  terminoAdevolver << " la palabra: " << ltr << endl;
         this->terminoAdevolver.append(ltr,1);
         //this->terminoAdevolver.append(new char(letra));
    }
   // cout << "->> devuevlo " << terminoAdevolver <<  endl;
    return resultado;
}

std::string * ParserMatrizExtendida::ultimaPalabra(){
    return new string(terminoAdevolver);
}

bool  ParserMatrizExtendida::eliminarSignos(char letra){
    
    if (letra ==' ' or letra == '-') return true;
    else if (this->isDelimitador(letra)) return true;
    
    return false;
}

void ParserMatrizExtendida::limpiarParserMatriz(){
    this->flagsReset();
    this->terminoAdevolver.clear();
    this->terminoTemporal.clear();
    this->pos = 0;
}